%matplotlib inline
from os.path import isdir,join,normpath
from os import listdir
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import image as mplimg
import random

def parseDirectory(directoryName, extension):
    '''
    This method returns a list of all filenames in the Directory directoryName. 
    For each file the complete absolute path is given in a normalized manner (with 
    double backslashes). Moreover only files with the specified extension are returned in 
    the list.
    '''
    if not isdir(directoryName): return

    imagefilenameslist=sorted([
        normpath(join(directoryName, fname))
        for fname in listdir(directoryName)
        if fname.lower().endswith('.'+extension)            
        ])
    
    return imagefilenameslist

train_images = parseDirectory(directoryName='.\\FaceRecogBilder\\training', extension='png')

def readImageToNumpyData(imageList):
    results = [mplimg.imread(i).reshape((1, -1))[0] for i in imageList] # Transform each png into numpy array format & 2-DIM to 1-DIM array
    results = [i/max(i) for i in results] # Normed pixel values
    return np.array(results)

normed_train_data = readImageToNumpyData(imageList=train_images) # Save noormed train data

normed_train_data.shape # Norm train data shape

(63, 33000)

average_img = np.average(normed_train_data, axis=0) # The average face

average_img.shape # The average face shape

(33000,)

normedArrayOfFaces = normed_train_data - average_img # Substract the average face from all images

normedArrayOfFaces.shape # normed array of faces shape

(63, 33000)

plt.imshow(average_img.reshape((220, 150)), cmap='gray') # Plot the average face

<matplotlib.image.AxesImage at 0x25b010b0f70>

def calculateEigenfaces(adjfaces):
    '''
    This function take the normed array of faces and ...
    - calculates the tranposed matrix
    - multiply the givn matrix with the transposed matrix
    - calculates the eigenvalues and eigenvectors == eigenfaces
    - transpose the eigefaces and return them as an array
    '''
    CV = np.dot(adjfaces, adjfaces.T) # Calculate covariance matrix
    eigenvalues, eigenvectors = np.linalg.eigh(CV) # Calculate eigenvalues and eigenvectors
    eigenfaces = np.dot(adjfaces.T, eigenvectors) # Calculate eigenfaces
    return eigenfaces

eigenfaces = calculateEigenfaces(adjfaces=normedArrayOfFaces) # Save the outut of the function

eigenfaces.shape # Eigenfaces shape

(33000, 63)

usub = eigenfaces.T[-6:] # The K (6) most important eigenfaces

usub = usub.T # Transpose usub for later

usub.shape # Usub shape

(33000, 6)

plt.figure(figsize=(10, 10)) # Define figure
for i in range(usub.shape[1]): # Iterate over usub at shape [1]
    plt.subplot(1, usub.shape[1], i + 1) # Add subplot to figure
    plt.imshow(usub[:, i].reshape(220, 150), cmap='gray') # Show the image with imshow
    plt.title(f"Eigenface {usub.shape[1] - i}") # Show title with index of eigenface
    plt.axis('off') # Remove axis

plt.show() # Show plot

# Reverse showcase (6, 5, 4, 3, 2, 1)

training_weights = np.dot(normedArrayOfFaces, usub) # Calculate w_k,i

training_weights.shape # w_k,i shape

(63, 6)

test_data = parseDirectory(directoryName='.\\FaceRecogBilder\\test', extension='png') # Load the test data

normed_test_data = readImageToNumpyData(imageList=test_data) # Norm test data and transform into numpy array format

normed_test_data.shape # test data shape

(21, 33000)

choosen_img = normed_test_data[0] # Choose only one image

choosen_img.shape # Choosen image shape

(33000,)

normedTestFace = choosen_img - average_img # Substract the average face of the training data from the test image

normedTestFace.shape # Normed test face shape

(33000,)

normedTestFace # Print the normed test face array

array([0.00670159, 0.00654614, 0.00703114, ..., 0.09701014, 0.08949825,
       0.08391508], dtype=float32)

# For later
normedTestFaces = normed_test_data - average_img # Calculate the normed faces for all the test data

# For later
normedTestFaces.shape # Normed test faces (all) shape

(21, 33000)

test_weight_single = np.dot(normedTestFace, usub) # Calculate w_k for single image

test_weight_single.shape # w_k shape

(6,)

distances = [np.linalg.norm(test_weight_single - train_weight) for train_weight in training_weights] # Calculate euclidean distances
min_index = np.argmin(distances) # Calculate argmin of the the distances
min_distance = distances[min_index] # Get the index of the distance at index min_index

plt.figure(figsize=(6, 3)) # Create figure

# Test image
plt.subplot(1, 2, 1) # Create subplot
plt.title("Test Image") # Title
plt.imshow(choosen_img.reshape(220, 150), cmap='gray') # Show image from the test data
plt.axis('off') # Remove axis

# Recognized image
recognized_image = normed_train_data[min_index]

plt.subplot(1, 2, 2) # Create subplot
plt.title(f"Recognized Image\nDistance: {min_distance:.2f}") # Title and the distance
plt.imshow(recognized_image.reshape(220, 150), cmap='gray') # Show recognized image from the train data
plt.axis('off') # Remove axis

plt.show() # Show plot

def calculate_distance(weights1, weights2):
    '''
    This function taked to weight and calculates the euclidean distance
    '''
    return np.linalg.norm(weights1 - weights2)

def calculate_weights(usub):
    training_weights = np.dot(normedArrayOfFaces, usub) # Calculate w_k,i
    test_weights = np.dot(normedTestFaces, usub) # Calculate w_k for all test images
    return training_weights, test_weights

def face_recogniation(normed_test_data, normedArrayOfFaces, k):

    eigenfaces = calculateEigenfaces(adjfaces=normedArrayOfFaces)
    usub = eigenfaces.T[-k:]
    usub = usub.T

    training_weights, test_weights = calculate_weights(usub=usub)

    for i, test_weight in enumerate(test_weights):
        distances = [calculate_distance(test_weight, train_weight) for train_weight in training_weights] # Calculate euclidean distances
        min_index = np.argmin(distances) # Calculate argmin of the the distances
        min_distance = distances[min_index] # Get the index of the distance at index min_index

        plt.figure(figsize=(6, 3)) # Create figure
        
        # Test image
        plt.subplot(1, 2, 1) # Create subplot
        plt.title("Test Image") # Title
        plt.imshow(normed_test_data[i].reshape(220, 150), cmap='gray') # Show image from the test data
        plt.axis('off') # Remove axis
        
        # Recognized image
        recognized_image = normed_train_data[min_index]

        plt.subplot(1, 2, 2) # Create subplot
        plt.title(f"Recognized Image\nDistance: {min_distance:.2f}") # Title and the distance
        plt.imshow(recognized_image.reshape(220, 150), cmap='gray') # Show recognized image from the train data
        plt.axis('off') # Remove axis
        
        plt.show() # Show plot

face_recogniation(normed_test_data=normed_test_data,
                  normedArrayOfFaces=normedArrayOfFaces,
                  k=5)

face_recogniation(normed_test_data=normed_test_data,
                  normedArrayOfFaces=normedArrayOfFaces,
                  k=10)

face_recogniation(normed_test_data=normed_test_data,
                  normedArrayOfFaces=normedArrayOfFaces,
                  k=15)

def horizontal_flip(train_images):
    '''
    This function taked an array of images, flip them horizontal, reshapes them and norm the values
    '''
    hi = [mplimg.imread(i) for i in train_images]
    hi = [np.flip(i, axis=1) for i in hi]
    hi = [i.reshape((1, -1))[0] for i in hi]
    hi = [i/max(i) for i in hi]
    return np.array(hi)

def horizontal_random_flip(test_images):
    '''
    Ths function takes an array of images and flip them horizontal by a probability of 50%.
    Reshape and normation is done afterwards.
    '''
    hri = [mplimg.imread(i) for i in test_images]
    hri = [np.flip(i, axis=1) if random.randint(0, 1) == 0 else i for i in hri]
    hri = [i.reshape((1, -1))[0] for i in hri]
    hri = [i/max(i) for i in hri]
    return np.array(hri)

test_images_random_flip = horizontal_random_flip(test_data) # Test images with 50% horizontal flip
test_images_random_flip.shape

(21, 33000)

train_images_horizontalFlip = horizontal_flip(train_images) # Training data with horizontal flip
train_images_horizontalFlip.shape

(63, 33000)

train_images_concatenated = np.concatenate((normed_train_data, train_images_horizontalFlip)) # Both training datasets concatenated
train_images_concatenated.shape

(126, 33000)

average_img_h = np.average(train_images_concatenated, axis=0) # Calculate the average img of new training data

plt.imshow(average_img_h.reshape((220, 150)), cmap='gray') # Show average image

<matplotlib.image.AxesImage at 0x25b044276d0>

normedArrayOfFaces_h = train_images_concatenated - average_img_h # New normed array of faces
normedArrayOfFaces_h.shape

(126, 33000)

eigenfaces_h = calculateEigenfaces(adjfaces=normedArrayOfFaces_h) # Calculate new eigenfaces
eigenfaces_h.shape

(33000, 126)

usub_h = eigenfaces_h.T[-6:] # The K (6) most important eigenfaces
usub_h = usub_h.T
usub_h.shape

(33000, 6)

plt.figure(figsize=(10, 10)) # Define figure
for i in range(usub_h.shape[1]): # Iterate over usub at shape [1]
    plt.subplot(1, usub_h.shape[1], i + 1) # Add subplot to figure
    plt.imshow(usub_h[:, i].reshape(220, 150), cmap='gray') # Show the image with imshow
    plt.title(f"Eigenface {usub_h.shape[1] - i}") # Show title with index of eigenface
    plt.axis('off') # Remove axis

plt.show() # Show plot

# Reverse showcase (6, 5, 4, 3, 2, 1)

face_recogniation(normed_test_data=normed_test_data,
                  normedArrayOfFaces=normedArrayOfFaces_h,
                  k=5)

face_recogniation(normed_test_data=normed_test_data,
                  normedArrayOfFaces=normedArrayOfFaces_h,
                  k=10)

face_recogniation(normed_test_data=normed_test_data,
                  normedArrayOfFaces=normedArrayOfFaces_h,
                  k=15)

Eigenface Gesichtserkennung¶

Abgabe:¶

Einführung¶

Lernziele:¶

Theorie zur Vorbereitung¶

Das Prinzip der Eigenface Gesichtserkennung¶

Genereller Ablauf¶

Trainingsphase¶

Erkennungsphase¶

Update (optional)¶

Bestimmung der Eigenfaces¶

Gesichtserkennung im Eigenspace¶

Vor dem Versuch zu klärende Fragen¶

Versuchsdurchführung¶

Einlesen der Gesichtsbilder in Numpy Arrays¶

Berechnung des Durchschnittbildes¶

Berechnung der Eigenfaces¶

Transformation der normierten Trainingsbilder in den Eigenface Raum¶

Erkennung¶

Hypothese¶

Die Anreicherung der Trainigsdaten durch horizontal gespiegelte Trainingsbilder verbessert die Gesichtserkennung, weil dadurch Merkmale besser in den Matrizen hervorstechen.¶

Fazit:¶